﻿/*--------------------------------------------------------------------------
* linq.js - LINQ for JavaScript
* ver 2.2.0.2 (Jan. 21th, 2011)
*
* created and maintained by neuecc <ils@neue.cc>
* licensed under Microsoft Public License(Ms-PL)
* http://neue.cc/
* http://linqjs.codeplex.com/
*--------------------------------------------------------------------------*/
layui.define(function (exports) {

    Enumerable = (function () {
        var Enumerable = function (getEnumerator) {
            this.GetEnumerator = getEnumerator;
        }

        // Generator

        Enumerable.Choice = function () // variable argument
        {
            var args = (arguments[0] instanceof Array) ? arguments[0] : arguments;

            return new Enumerable(function () {
                return new IEnumerator(
                    Functions.Blank,
                    function () {
                        return this.Yield(args[Math.floor(Math.random() * args.length)]);
                    },
                    Functions.Blank);
            });
        }

        Enumerable.Cycle = function () // variable argument
        {
            var args = (arguments[0] instanceof Array) ? arguments[0] : arguments;

            return new Enumerable(function () {
                var index = 0;
                return new IEnumerator(
                    Functions.Blank,
                    function () {
                        if (index >= args.length) index = 0;
                        return this.Yield(args[index++]);
                    },
                    Functions.Blank);
            });
        }

        Enumerable.Empty = function () {
            return new Enumerable(function () {
                return new IEnumerator(
                    Functions.Blank,
                    function () { return false; },
                    Functions.Blank);
            });
        }

        Enumerable.From = function (obj) {
            if (obj == null) {
                return Enumerable.Empty();
            }
            if (obj instanceof Enumerable) {
                return obj;
            }
            if (typeof obj == Types.Number || typeof obj == Types.Boolean) {
                return Enumerable.Repeat(obj, 1);
            }
            if (typeof obj == Types.String) {
                return new Enumerable(function () {
                    var index = 0;
                    return new IEnumerator(
                        Functions.Blank,
                        function () {
                            return (index < obj.length) ? this.Yield(obj.charAt(index++)) : false;
                        },
                        Functions.Blank);
                });
            }
            if (typeof obj != Types.Function) {
                // array or array like object
                if (typeof obj.length == Types.Number) {
                    return new ArrayEnumerable(obj);
                }

                // JScript's IEnumerable
                if (!(obj instanceof Object) && Utils.IsIEnumerable(obj)) {
                    return new Enumerable(function () {
                        var isFirst = true;
                        var enumerator;
                        return new IEnumerator(
                            function () { enumerator = new Enumerator(obj); },
                            function () {
                                if (isFirst) isFirst = false;
                                else enumerator.moveNext();

                                return (enumerator.atEnd()) ? false : this.Yield(enumerator.item());
                            },
                            Functions.Blank);
                    });
                }
            }

            // case function/object : Create KeyValuePair[]
            return new Enumerable(function () {
                var array = [];
                var index = 0;

                return new IEnumerator(
                    function () {
                        for (var key in obj) {
                            if (!(obj[key] instanceof Function)) {
                                array.push({ Key: key, Value: obj[key] });
                            }
                        }
                    },
                    function () {
                        return (index < array.length)
                            ? this.Yield(array[index++])
                            : false;
                    },
                    Functions.Blank);
            });
        },

        Enumerable.Return = function (element) {
            return Enumerable.Repeat(element, 1);
        }

        // Overload:function(input, pattern)
        // Overload:function(input, pattern, flags)
        Enumerable.Matches = function (input, pattern, flags) {
            if (flags == null) flags = "";
            if (pattern instanceof RegExp) {
                flags += (pattern.ignoreCase) ? "i" : "";
                flags += (pattern.multiline) ? "m" : "";
                pattern = pattern.source;
            }
            if (flags.indexOf("g") === -1) flags += "g";

            return new Enumerable(function () {
                var regex;
                return new IEnumerator(
                    function () { regex = new RegExp(pattern, flags) },
                    function () {
                        var match = regex.exec(input);
                        return (match) ? this.Yield(match) : false;
                    },
                    Functions.Blank);
            });
        }

        // Overload:function(start, count)
        // Overload:function(start, count, step)
        Enumerable.Range = function (start, count, step) {
            if (step == null) step = 1;
            return Enumerable.ToInfinity(start, step).Take(count);
        }

        // Overload:function(start, count)
        // Overload:function(start, count, step)
        Enumerable.RangeDown = function (start, count, step) {
            if (step == null) step = 1;
            return Enumerable.ToNegativeInfinity(start, step).Take(count);
        }

        // Overload:function(start, to)
        // Overload:function(start, to, step)
        Enumerable.RangeTo = function (start, to, step) {
            if (step == null) step = 1;
            return (start < to)
                ? Enumerable.ToInfinity(start, step).TakeWhile(function (i) { return i <= to; })
                : Enumerable.ToNegativeInfinity(start, step).TakeWhile(function (i) { return i >= to; })
        }

        // Overload:function(obj)
        // Overload:function(obj, num)
        Enumerable.Repeat = function (obj, num) {
            if (num != null) return Enumerable.Repeat(obj).Take(num);

            return new Enumerable(function () {
                return new IEnumerator(
                    Functions.Blank,
                    function () { return this.Yield(obj); },
                    Functions.Blank);
            });
        }

        Enumerable.RepeatWithFinalize = function (initializer, finalizer) {
            initializer = Utils.CreateLambda(initializer);
            finalizer = Utils.CreateLambda(finalizer);

            return new Enumerable(function () {
                var element;
                return new IEnumerator(
                    function () { element = initializer(); },
                    function () { return this.Yield(element); },
                    function () {
                        if (element != null) {
                            finalizer(element);
                            element = null;
                        }
                    });
            });
        }

        // Overload:function(func)
        // Overload:function(func, count)
        Enumerable.Generate = function (func, count) {
            if (count != null) return Enumerable.Generate(func).Take(count);
            func = Utils.CreateLambda(func);

            return new Enumerable(function () {
                return new IEnumerator(
                    Functions.Blank,
                    function () { return this.Yield(func()); },
                    Functions.Blank);
            });
        }

        // Overload:function()
        // Overload:function(start)
        // Overload:function(start, step)
        Enumerable.ToInfinity = function (start, step) {
            if (start == null) start = 0;
            if (step == null) step = 1;

            return new Enumerable(function () {
                var value;
                return new IEnumerator(
                    function () { value = start - step },
                    function () { return this.Yield(value += step); },
                    Functions.Blank);
            });
        }

        // Overload:function()
        // Overload:function(start)
        // Overload:function(start, step)
        Enumerable.ToNegativeInfinity = function (start, step) {
            if (start == null) start = 0;
            if (step == null) step = 1;

            return new Enumerable(function () {
                var value;
                return new IEnumerator(
                    function () { value = start + step },
                    function () { return this.Yield(value -= step); },
                    Functions.Blank);
            });
        }

        Enumerable.Unfold = function (seed, func) {
            func = Utils.CreateLambda(func);

            return new Enumerable(function () {
                var isFirst = true;
                var value;
                return new IEnumerator(
                    Functions.Blank,
                    function () {
                        if (isFirst) {
                            isFirst = false;
                            value = seed;
                            return this.Yield(value);
                        }
                        value = func(value);
                        return this.Yield(value);
                    },
                    Functions.Blank);
            });
        }

        // Extension Methods

        Enumerable.prototype =
        {
            /* Projection and Filtering Methods */

            // Overload:function(func)
            // Overload:function(func, resultSelector<element>)
            // Overload:function(func, resultSelector<element, nestLevel>)
            CascadeBreadthFirst: function (func, resultSelector) {
                var source = this;
                func = Utils.CreateLambda(func);
                resultSelector = Utils.CreateLambda(resultSelector);

                return new Enumerable(function () {
                    var enumerator;
                    var nestLevel = 0;
                    var buffer = [];

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            while (true) {
                                if (enumerator.MoveNext()) {
                                    buffer.push(enumerator.Current());
                                    return this.Yield(resultSelector(enumerator.Current(), nestLevel));
                                }

                                var next = Enumerable.From(buffer).SelectMany(function (x) { return func(x); });
                                if (!next.Any()) {
                                    return false;
                                }
                                else {
                                    nestLevel++;
                                    buffer = [];
                                    Utils.Dispose(enumerator);
                                    enumerator = next.GetEnumerator();
                                }
                            }
                        },
                        function () { Utils.Dispose(enumerator); });
                });
            },

            // Overload:function(func)
            // Overload:function(func, resultSelector<element>)
            // Overload:function(func, resultSelector<element, nestLevel>)
            CascadeDepthFirst: function (func, resultSelector) {
                var source = this;
                func = Utils.CreateLambda(func);
                resultSelector = Utils.CreateLambda(resultSelector);

                return new Enumerable(function () {
                    var enumeratorStack = [];
                    var enumerator;

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            while (true) {
                                if (enumerator.MoveNext()) {
                                    var value = resultSelector(enumerator.Current(), enumeratorStack.length);
                                    enumeratorStack.push(enumerator);
                                    enumerator = Enumerable.From(func(enumerator.Current())).GetEnumerator();
                                    return this.Yield(value);
                                }

                                if (enumeratorStack.length <= 0) return false;
                                Utils.Dispose(enumerator);
                                enumerator = enumeratorStack.pop();
                            }
                        },
                        function () {
                            try { Utils.Dispose(enumerator); }
                            finally { Enumerable.From(enumeratorStack).ForEach(function (s) { s.Dispose(); }) }
                        });
                });
            },

            Flatten: function () {
                var source = this;

                return new Enumerable(function () {
                    var enumerator;
                    var middleEnumerator = null;

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            while (true) {
                                if (middleEnumerator != null) {
                                    if (middleEnumerator.MoveNext()) {
                                        return this.Yield(middleEnumerator.Current());
                                    }
                                    else {
                                        middleEnumerator = null;
                                    }
                                }

                                if (enumerator.MoveNext()) {
                                    if (enumerator.Current() instanceof Array) {
                                        Utils.Dispose(middleEnumerator);
                                        middleEnumerator = Enumerable.From(enumerator.Current())
                                            .SelectMany(Functions.Identity)
                                            .Flatten()
                                            .GetEnumerator();
                                        continue;
                                    }
                                    else {
                                        return this.Yield(enumerator.Current());
                                    }
                                }

                                return false;
                            }
                        },
                        function () {
                            try { Utils.Dispose(enumerator); }
                            finally { Utils.Dispose(middleEnumerator); }
                        });
                });
            },

            Pairwise: function (selector) {
                var source = this;
                selector = Utils.CreateLambda(selector);

                return new Enumerable(function () {
                    var enumerator;

                    return new IEnumerator(
                        function () {
                            enumerator = source.GetEnumerator();
                            enumerator.MoveNext();
                        },
                        function () {
                            var prev = enumerator.Current();
                            return (enumerator.MoveNext())
                                ? this.Yield(selector(prev, enumerator.Current()))
                                : false;
                        },
                        function () { Utils.Dispose(enumerator); });
                });
            },

            // Overload:function(func)
            // Overload:function(seed,func<value,element>)
            // Overload:function(seed,func<value,element>,resultSelector)
            Scan: function (seed, func, resultSelector) {
                if (resultSelector != null) return this.Scan(seed, func).Select(resultSelector);

                var isUseSeed;
                if (func == null) {
                    func = Utils.CreateLambda(seed); // arguments[0]
                    isUseSeed = false;
                }
                else {
                    func = Utils.CreateLambda(func);
                    isUseSeed = true;
                }
                var source = this;

                return new Enumerable(function () {
                    var enumerator;
                    var value;
                    var isFirst = true;

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            if (isFirst) {
                                isFirst = false;
                                if (!isUseSeed) {
                                    if (enumerator.MoveNext()) {
                                        return this.Yield(value = enumerator.Current());
                                    }
                                }
                                else {
                                    return this.Yield(value = seed);
                                }
                            }

                            return (enumerator.MoveNext())
                                ? this.Yield(value = func(value, enumerator.Current()))
                                : false;
                        },
                        function () { Utils.Dispose(enumerator); });
                });
            },

            // Overload:function(selector<element>)
            // Overload:function(selector<element,index>)
            Select: function (selector) {
                var source = this;
                selector = Utils.CreateLambda(selector);

                return new Enumerable(function () {
                    var enumerator;
                    var index = 0;

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            return (enumerator.MoveNext())
                                ? this.Yield(selector(enumerator.Current(), index++))
                                : false;
                        },
                        function () { Utils.Dispose(enumerator); })
                });
            },

            // Overload:function(collectionSelector<element>)
            // Overload:function(collectionSelector<element,index>)
            // Overload:function(collectionSelector<element>,resultSelector)
            // Overload:function(collectionSelector<element,index>,resultSelector)
            SelectMany: function (collectionSelector, resultSelector) {
                var source = this;
                collectionSelector = Utils.CreateLambda(collectionSelector);
                if (resultSelector == null) resultSelector = function (a, b) { return b; }
                resultSelector = Utils.CreateLambda(resultSelector);

                return new Enumerable(function () {
                    var enumerator;
                    var middleEnumerator = undefined;
                    var index = 0;

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            if (middleEnumerator === undefined) {
                                if (!enumerator.MoveNext()) return false;
                            }
                            do {
                                if (middleEnumerator == null) {
                                    var middleSeq = collectionSelector(enumerator.Current(), index++);
                                    middleEnumerator = Enumerable.From(middleSeq).GetEnumerator();
                                }
                                if (middleEnumerator.MoveNext()) {
                                    return this.Yield(resultSelector(enumerator.Current(), middleEnumerator.Current()));
                                }
                                Utils.Dispose(middleEnumerator);
                                middleEnumerator = null;
                            } while (enumerator.MoveNext())
                            return false;
                        },
                        function () {
                            try { Utils.Dispose(enumerator); }
                            finally { Utils.Dispose(middleEnumerator); }
                        })
                });
            },

            // Overload:function(predicate<element>)
            // Overload:function(predicate<element,index>)
            Where: function (predicate) {
                predicate = Utils.CreateLambda(predicate);
                var source = this;

                return new Enumerable(function () {
                    var enumerator;
                    var index = 0;

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            while (enumerator.MoveNext()) {
                                if (predicate(enumerator.Current(), index++)) {
                                    return this.Yield(enumerator.Current());
                                }
                            }
                            return false;
                        },
                        function () { Utils.Dispose(enumerator); })
                });
            },

            OfType: function (type) {
                var typeName;
                switch (type) {
                    case Number: typeName = Types.Number; break;
                    case String: typeName = Types.String; break;
                    case Boolean: typeName = Types.Boolean; break;
                    case Function: typeName = Types.Function; break;
                    default: typeName = null; break;
                }
                return (typeName === null)
                    ? this.Where(function (x) { return x instanceof type })
                    : this.Where(function (x) { return typeof x === typeName });
            },

            // Overload:function(second,selector<outer,inner>)
            // Overload:function(second,selector<outer,inner,index>)
            Zip: function (second, selector) {
                selector = Utils.CreateLambda(selector);
                var source = this;

                return new Enumerable(function () {
                    var firstEnumerator;
                    var secondEnumerator;
                    var index = 0;

                    return new IEnumerator(
                        function () {
                            firstEnumerator = source.GetEnumerator();
                            secondEnumerator = Enumerable.From(second).GetEnumerator();
                        },
                        function () {
                            if (firstEnumerator.MoveNext() && secondEnumerator.MoveNext()) {
                                return this.Yield(selector(firstEnumerator.Current(), secondEnumerator.Current(), index++));
                            }
                            return false;
                        },
                        function () {
                            try { Utils.Dispose(firstEnumerator); }
                            finally { Utils.Dispose(secondEnumerator); }
                        })
                });
            },

            /* Join Methods */

            // Overload:function (inner, outerKeySelector, innerKeySelector, resultSelector)
            // Overload:function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector)
            Join: function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector) {
                outerKeySelector = Utils.CreateLambda(outerKeySelector);
                innerKeySelector = Utils.CreateLambda(innerKeySelector);
                resultSelector = Utils.CreateLambda(resultSelector);
                compareSelector = Utils.CreateLambda(compareSelector);
                var source = this;

                return new Enumerable(function () {
                    var outerEnumerator;
                    var lookup;
                    var innerElements = null;
                    var innerCount = 0;

                    return new IEnumerator(
                        function () {
                            outerEnumerator = source.GetEnumerator();
                            lookup = Enumerable.From(inner).ToLookup(innerKeySelector, Functions.Identity, compareSelector);
                        },
                        function () {
                            while (true) {
                                if (innerElements != null) {
                                    var innerElement = innerElements[innerCount++];
                                    if (innerElement !== undefined) {
                                        return this.Yield(resultSelector(outerEnumerator.Current(), innerElement));
                                    }

                                    innerElement = null;
                                    innerCount = 0;
                                }

                                if (outerEnumerator.MoveNext()) {
                                    var key = outerKeySelector(outerEnumerator.Current());
                                    innerElements = lookup.Get(key).ToArray();
                                }
                                else {
                                    return false;
                                }
                            }
                        },
                        function () { Utils.Dispose(outerEnumerator); })
                });
            },

            // Overload:function (inner, outerKeySelector, innerKeySelector, resultSelector)
            // Overload:function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector)
            GroupJoin: function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector) {
                outerKeySelector = Utils.CreateLambda(outerKeySelector);
                innerKeySelector = Utils.CreateLambda(innerKeySelector);
                resultSelector = Utils.CreateLambda(resultSelector);
                compareSelector = Utils.CreateLambda(compareSelector);
                var source = this;

                return new Enumerable(function () {
                    var enumerator = source.GetEnumerator();
                    var lookup = null;

                    return new IEnumerator(
                        function () {
                            enumerator = source.GetEnumerator();
                            lookup = Enumerable.From(inner).ToLookup(innerKeySelector, Functions.Identity, compareSelector);
                        },
                        function () {
                            if (enumerator.MoveNext()) {
                                var innerElement = lookup.Get(outerKeySelector(enumerator.Current()));
                                return this.Yield(resultSelector(enumerator.Current(), innerElement));
                            }
                            return false;
                        },
                        function () { Utils.Dispose(enumerator); })
                });
            },

            /* Set Methods */

            All: function (predicate) {
                predicate = Utils.CreateLambda(predicate);

                var result = true;
                this.ForEach(function (x) {
                    if (!predicate(x)) {
                        result = false;
                        return false; // break
                    }
                });
                return result;
            },

            // Overload:function()
            // Overload:function(predicate)
            Any: function (predicate) {
                predicate = Utils.CreateLambda(predicate);

                var enumerator = this.GetEnumerator();
                try {
                    if (arguments.length == 0) return enumerator.MoveNext(); // case:function()

                    while (enumerator.MoveNext()) // case:function(predicate)
                    {
                        if (predicate(enumerator.Current())) return true;
                    }
                    return false;
                }
                finally { Utils.Dispose(enumerator); }
            },

            Concat: function (second) {
                var source = this;

                return new Enumerable(function () {
                    var firstEnumerator;
                    var secondEnumerator;

                    return new IEnumerator(
                        function () { firstEnumerator = source.GetEnumerator(); },
                        function () {
                            if (secondEnumerator == null) {
                                if (firstEnumerator.MoveNext()) return this.Yield(firstEnumerator.Current());
                                secondEnumerator = Enumerable.From(second).GetEnumerator();
                            }
                            if (secondEnumerator.MoveNext()) return this.Yield(secondEnumerator.Current());
                            return false;
                        },
                        function () {
                            try { Utils.Dispose(firstEnumerator); }
                            finally { Utils.Dispose(secondEnumerator); }
                        })
                });
            },

            Insert: function (index, second) {
                var source = this;

                return new Enumerable(function () {
                    var firstEnumerator;
                    var secondEnumerator;
                    var count = 0;
                    var isEnumerated = false;

                    return new IEnumerator(
                        function () {
                            firstEnumerator = source.GetEnumerator();
                            secondEnumerator = Enumerable.From(second).GetEnumerator();
                        },
                        function () {
                            if (count == index && secondEnumerator.MoveNext()) {
                                isEnumerated = true;
                                return this.Yield(secondEnumerator.Current());
                            }
                            if (firstEnumerator.MoveNext()) {
                                count++;
                                return this.Yield(firstEnumerator.Current());
                            }
                            if (!isEnumerated && secondEnumerator.MoveNext()) {
                                return this.Yield(secondEnumerator.Current());
                            }
                            return false;
                        },
                        function () {
                            try { Utils.Dispose(firstEnumerator); }
                            finally { Utils.Dispose(secondEnumerator); }
                        })
                });
            },

            Alternate: function (value) {
                value = Enumerable.Return(value);
                return this.SelectMany(function (elem) {
                    return Enumerable.Return(elem).Concat(value);
                }).TakeExceptLast();
            },

            // Overload:function(value)
            // Overload:function(value, compareSelector)
            Contains: function (value, compareSelector) {
                compareSelector = Utils.CreateLambda(compareSelector);
                var enumerator = this.GetEnumerator();
                try {
                    while (enumerator.MoveNext()) {
                        if (compareSelector(enumerator.Current()) === value) return true;
                    }
                    return false;
                }
                finally { Utils.Dispose(enumerator) }
            },

            DefaultIfEmpty: function (defaultValue) {
                var source = this;

                return new Enumerable(function () {
                    var enumerator;
                    var isFirst = true;

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            if (enumerator.MoveNext()) {
                                isFirst = false;
                                return this.Yield(enumerator.Current());
                            }
                            else if (isFirst) {
                                isFirst = false;
                                return this.Yield(defaultValue);
                            }
                            return false;
                        },
                        function () { Utils.Dispose(enumerator); })
                });
            },

            // Overload:function()
            // Overload:function(compareSelector)
            Distinct: function (compareSelector) {
                return this.Except(Enumerable.Empty(), compareSelector);
            },

            // Overload:function(second)
            // Overload:function(second, compareSelector)
            Except: function (second, compareSelector) {
                compareSelector = Utils.CreateLambda(compareSelector);
                var source = this;

                return new Enumerable(function () {
                    var enumerator;
                    var keys;

                    return new IEnumerator(
                        function () {
                            enumerator = source.GetEnumerator();
                            keys = new Dictionary(compareSelector);
                            Enumerable.From(second).ForEach(function (key) { keys.Add(key); });
                        },
                        function () {
                            while (enumerator.MoveNext()) {
                                var current = enumerator.Current();
                                if (!keys.Contains(current)) {
                                    keys.Add(current);
                                    return this.Yield(current);
                                }
                            }
                            return false;
                        },
                        function () { Utils.Dispose(enumerator); })
                });
            },

            // Overload:function(second)
            // Overload:function(second, compareSelector)
            Intersect: function (second, compareSelector) {
                compareSelector = Utils.CreateLambda(compareSelector);
                var source = this;

                return new Enumerable(function () {
                    var enumerator;
                    var keys;
                    var outs;

                    return new IEnumerator(
                        function () {
                            enumerator = source.GetEnumerator();

                            keys = new Dictionary(compareSelector);
                            Enumerable.From(second).ForEach(function (key) { keys.Add(key); });
                            outs = new Dictionary(compareSelector);
                        },
                        function () {
                            while (enumerator.MoveNext()) {
                                var current = enumerator.Current();
                                if (!outs.Contains(current) && keys.Contains(current)) {
                                    outs.Add(current);
                                    return this.Yield(current);
                                }
                            }
                            return false;
                        },
                        function () { Utils.Dispose(enumerator); })
                });
            },

            // Overload:function(second)
            // Overload:function(second, compareSelector)
            SequenceEqual: function (second, compareSelector) {
                compareSelector = Utils.CreateLambda(compareSelector);

                var firstEnumerator = this.GetEnumerator();
                try {
                    var secondEnumerator = Enumerable.From(second).GetEnumerator();
                    try {
                        while (firstEnumerator.MoveNext()) {
                            if (!secondEnumerator.MoveNext()
                                || compareSelector(firstEnumerator.Current()) !== compareSelector(secondEnumerator.Current())) {
                                return false;
                            }
                        }

                        if (secondEnumerator.MoveNext()) return false;
                        return true;
                    }
                    finally { Utils.Dispose(secondEnumerator); }
                }
                finally { Utils.Dispose(firstEnumerator); }
            },

            Union: function (second, compareSelector) {
                compareSelector = Utils.CreateLambda(compareSelector);
                var source = this;

                return new Enumerable(function () {
                    var firstEnumerator;
                    var secondEnumerator;
                    var keys;

                    return new IEnumerator(
                        function () {
                            firstEnumerator = source.GetEnumerator();
                            keys = new Dictionary(compareSelector);
                        },
                        function () {
                            var current;
                            if (secondEnumerator === undefined) {
                                while (firstEnumerator.MoveNext()) {
                                    current = firstEnumerator.Current();
                                    if (!keys.Contains(current)) {
                                        keys.Add(current);
                                        return this.Yield(current);
                                    }
                                }
                                secondEnumerator = Enumerable.From(second).GetEnumerator();
                            }
                            while (secondEnumerator.MoveNext()) {
                                current = secondEnumerator.Current();
                                if (!keys.Contains(current)) {
                                    keys.Add(current);
                                    return this.Yield(current);
                                }
                            }
                            return false;
                        },
                        function () {
                            try { Utils.Dispose(firstEnumerator); }
                            finally { Utils.Dispose(secondEnumerator); }
                        })
                });
            },

            /* Ordering Methods */

            OrderBy: function (keySelector) {
                return new OrderedEnumerable(this, keySelector, false);
            },

            OrderByDescending: function (keySelector) {
                return new OrderedEnumerable(this, keySelector, true);
            },

            Reverse: function () {
                var source = this;

                return new Enumerable(function () {
                    var buffer;
                    var index;

                    return new IEnumerator(
                        function () {
                            buffer = source.ToArray();
                            index = buffer.length;
                        },
                        function () {
                            return (index > 0)
                                ? this.Yield(buffer[--index])
                                : false;
                        },
                        Functions.Blank)
                });
            },

            Shuffle: function () {
                var source = this;

                return new Enumerable(function () {
                    var buffer;

                    return new IEnumerator(
                        function () { buffer = source.ToArray(); },
                        function () {
                            if (buffer.length > 0) {
                                var i = Math.floor(Math.random() * buffer.length);
                                return this.Yield(buffer.splice(i, 1)[0]);
                            }
                            return false;
                        },
                        Functions.Blank)
                });
            },

            /* Grouping Methods */

            // Overload:function(keySelector)
            // Overload:function(keySelector,elementSelector)
            // Overload:function(keySelector,elementSelector,resultSelector)
            // Overload:function(keySelector,elementSelector,resultSelector,compareSelector)
            GroupBy: function (keySelector, elementSelector, resultSelector, compareSelector) {
                var source = this;
                keySelector = Utils.CreateLambda(keySelector);
                elementSelector = Utils.CreateLambda(elementSelector);
                if (resultSelector != null) resultSelector = Utils.CreateLambda(resultSelector);
                compareSelector = Utils.CreateLambda(compareSelector);

                return new Enumerable(function () {
                    var enumerator;

                    return new IEnumerator(
                        function () {
                            enumerator = source.ToLookup(keySelector, elementSelector, compareSelector)
                                .ToEnumerable()
                                .GetEnumerator();
                        },
                        function () {
                            while (enumerator.MoveNext()) {
                                return (resultSelector == null)
                                    ? this.Yield(enumerator.Current())
                                    : this.Yield(resultSelector(enumerator.Current().Key(), enumerator.Current()));
                            }
                            return false;
                        },
                        function () { Utils.Dispose(enumerator); })
                });
            },

            // Overload:function(keySelector)
            // Overload:function(keySelector,elementSelector)
            // Overload:function(keySelector,elementSelector,resultSelector)
            // Overload:function(keySelector,elementSelector,resultSelector,compareSelector)
            PartitionBy: function (keySelector, elementSelector, resultSelector, compareSelector) {

                var source = this;
                keySelector = Utils.CreateLambda(keySelector);
                elementSelector = Utils.CreateLambda(elementSelector);
                compareSelector = Utils.CreateLambda(compareSelector);
                var hasResultSelector;
                if (resultSelector == null) {
                    hasResultSelector = false;
                    resultSelector = function (key, group) { return new Grouping(key, group) }
                }
                else {
                    hasResultSelector = true;
                    resultSelector = Utils.CreateLambda(resultSelector);
                }

                return new Enumerable(function () {
                    var enumerator;
                    var key;
                    var compareKey;
                    var group = [];

                    return new IEnumerator(
                        function () {
                            enumerator = source.GetEnumerator();
                            if (enumerator.MoveNext()) {
                                key = keySelector(enumerator.Current());
                                compareKey = compareSelector(key);
                                group.push(elementSelector(enumerator.Current()));
                            }
                        },
                        function () {
                            var hasNext;
                            while ((hasNext = enumerator.MoveNext()) == true) {
                                if (compareKey === compareSelector(keySelector(enumerator.Current()))) {
                                    group.push(elementSelector(enumerator.Current()));
                                }
                                else break;
                            }

                            if (group.length > 0) {
                                var result = (hasResultSelector)
                                    ? resultSelector(key, Enumerable.From(group))
                                    : resultSelector(key, group);
                                if (hasNext) {
                                    key = keySelector(enumerator.Current());
                                    compareKey = compareSelector(key);
                                    group = [elementSelector(enumerator.Current())];
                                }
                                else group = [];

                                return this.Yield(result);
                            }

                            return false;
                        },
                        function () { Utils.Dispose(enumerator); })
                });
            },

            BufferWithCount: function (count) {
                var source = this;

                return new Enumerable(function () {
                    var enumerator;

                    return new IEnumerator(
                    function () { enumerator = source.GetEnumerator(); },
                    function () {
                        var array = [];
                        var index = 0;
                        while (enumerator.MoveNext()) {
                            array.push(enumerator.Current());
                            if (++index >= count) return this.Yield(array);
                        }
                        if (array.length > 0) return this.Yield(array);
                        return false;
                    },
                    function () { Utils.Dispose(enumerator); })
                });
            },

            /* Aggregate Methods */

            // Overload:function(func)
            // Overload:function(seed,func)
            // Overload:function(seed,func,resultSelector)
            Aggregate: function (seed, func, resultSelector) {
                return this.Scan(seed, func, resultSelector).Last();
            },

            // Overload:function()
            // Overload:function(selector)
            Average: function (selector) {
                selector = Utils.CreateLambda(selector);

                var sum = 0;
                var count = 0;
                this.ForEach(function (x) {
                    sum += selector(x);
                    ++count;
                });

                return sum / count;
            },

            // Overload:function()
            // Overload:function(predicate)
            Count: function (predicate) {
                predicate = (predicate == null) ? Functions.True : Utils.CreateLambda(predicate);

                var count = 0;
                this.ForEach(function (x, i) {
                    if (predicate(x, i))++count;
                });
                return count;
            },

            // Overload:function()
            // Overload:function(selector)
            Max: function (selector) {
                if (selector == null) selector = Functions.Identity;
                return this.Select(selector).Aggregate(function (a, b) { return (a > b) ? a : b; });
            },

            // Overload:function()
            // Overload:function(selector)
            Min: function (selector) {
                if (selector == null) selector = Functions.Identity;
                return this.Select(selector).Aggregate(function (a, b) { return (a < b) ? a : b; });
            },

            MaxBy: function (keySelector) {
                keySelector = Utils.CreateLambda(keySelector);
                return this.Aggregate(function (a, b) { return (keySelector(a) > keySelector(b)) ? a : b });
            },

            MinBy: function (keySelector) {
                keySelector = Utils.CreateLambda(keySelector);
                return this.Aggregate(function (a, b) { return (keySelector(a) < keySelector(b)) ? a : b });
            },

            // Overload:function()
            // Overload:function(selector)
            Sum: function (selector) {
                if (selector == null) selector = Functions.Identity;
                return this.Select(selector).Aggregate(0, function (a, b) { return a + b; });
            },

            /* Paging Methods */

            ElementAt: function (index) {
                var value;
                var found = false;
                this.ForEach(function (x, i) {
                    if (i == index) {
                        value = x;
                        found = true;
                        return false;
                    }
                });

                if (!found) throw new Error("index is less than 0 or greater than or equal to the number of elements in source.");
                return value;
            },

            ElementAtOrDefault: function (index, defaultValue) {
                var value;
                var found = false;
                this.ForEach(function (x, i) {
                    if (i == index) {
                        value = x;
                        found = true;
                        return false;
                    }
                });

                return (!found) ? defaultValue : value;
            },

            // Overload:function()
            // Overload:function(predicate)
            First: function (predicate) {
                if (predicate != null) return this.Where(predicate).First();

                var value;
                var found = false;
                this.ForEach(function (x) {
                    value = x;
                    found = true;
                    return false;
                });

                if (!found) throw new Error("First:No element satisfies the condition.");
                return value;
            },

            // Overload:function(defaultValue)
            // Overload:function(defaultValue,predicate)
            FirstOrDefault: function (defaultValue, predicate) {
                if (predicate != null) return this.Where(predicate).FirstOrDefault(defaultValue);

                var value;
                var found = false;
                this.ForEach(function (x) {
                    value = x;
                    found = true;
                    return false;
                });
                return (!found) ? defaultValue : value;
            },

            // Overload:function()
            // Overload:function(predicate)
            Last: function (predicate) {
                if (predicate != null) return this.Where(predicate).Last();

                var value;
                var found = false;
                this.ForEach(function (x) {
                    found = true;
                    value = x;
                });

                if (!found) throw new Error("Last:No element satisfies the condition.");
                return value;
            },

            // Overload:function(defaultValue)
            // Overload:function(defaultValue,predicate)
            LastOrDefault: function (defaultValue, predicate) {
                if (predicate != null) return this.Where(predicate).LastOrDefault(defaultValue);

                var value;
                var found = false;
                this.ForEach(function (x) {
                    found = true;
                    value = x;
                });
                return (!found) ? defaultValue : value;
            },

            // Overload:function()
            // Overload:function(predicate)
            Single: function (predicate) {
                if (predicate != null) return this.Where(predicate).Single();

                var value;
                var found = false;
                this.ForEach(function (x) {
                    if (!found) {
                        found = true;
                        value = x;
                    }
                    else throw new Error("Single:sequence contains more than one element.");
                });

                if (!found) throw new Error("Single:No element satisfies the condition.");
                return value;
            },

            // Overload:function(defaultValue)
            // Overload:function(defaultValue,predicate)
            SingleOrDefault: function (defaultValue, predicate) {
                if (predicate != null) return this.Where(predicate).SingleOrDefault(defaultValue);

                var value;
                var found = false;
                this.ForEach(function (x) {
                    if (!found) {
                        found = true;
                        value = x;
                    }
                    else throw new Error("Single:sequence contains more than one element.");
                });

                return (!found) ? defaultValue : value;
            },

            Skip: function (count) {
                var source = this;

                return new Enumerable(function () {
                    var enumerator;
                    var index = 0;

                    return new IEnumerator(
                        function () {
                            enumerator = source.GetEnumerator();
                            while (index++ < count && enumerator.MoveNext()) { };
                        },
                        function () {
                            return (enumerator.MoveNext())
                                ? this.Yield(enumerator.Current())
                                : false;
                        },
                        function () { Utils.Dispose(enumerator); })
                });
            },

            // Overload:function(predicate<element>)
            // Overload:function(predicate<element,index>)
            SkipWhile: function (predicate) {
                predicate = Utils.CreateLambda(predicate);
                var source = this;

                return new Enumerable(function () {
                    var enumerator;
                    var index = 0;
                    var isSkipEnd = false;

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            while (!isSkipEnd) {
                                if (enumerator.MoveNext()) {
                                    if (!predicate(enumerator.Current(), index++)) {
                                        isSkipEnd = true;
                                        return this.Yield(enumerator.Current());
                                    }
                                    continue;
                                }
                                else return false;
                            }

                            return (enumerator.MoveNext())
                                ? this.Yield(enumerator.Current())
                                : false;

                        },
                        function () { Utils.Dispose(enumerator); });
                });
            },

            Take: function (count) {
                var source = this;

                return new Enumerable(function () {
                    var enumerator;
                    var index = 0;

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            return (index++ < count && enumerator.MoveNext())
                                ? this.Yield(enumerator.Current())
                                : false;
                        },
                        function () { Utils.Dispose(enumerator); }
                    )
                });
            },

            // Overload:function(predicate<element>)
            // Overload:function(predicate<element,index>)
            TakeWhile: function (predicate) {
                predicate = Utils.CreateLambda(predicate);
                var source = this;

                return new Enumerable(function () {
                    var enumerator;
                    var index = 0;

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            return (enumerator.MoveNext() && predicate(enumerator.Current(), index++))
                                ? this.Yield(enumerator.Current())
                                : false;
                        },
                        function () { Utils.Dispose(enumerator); });
                });
            },

            // Overload:function()
            // Overload:function(count)
            TakeExceptLast: function (count) {
                if (count == null) count = 1;
                var source = this;

                return new Enumerable(function () {
                    if (count <= 0) return source.GetEnumerator(); // do nothing

                    var enumerator;
                    var q = [];

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            while (enumerator.MoveNext()) {
                                if (q.length == count) {
                                    q.push(enumerator.Current());
                                    return this.Yield(q.shift());
                                }
                                q.push(enumerator.Current());
                            }
                            return false;
                        },
                        function () { Utils.Dispose(enumerator); });
                });
            },

            TakeFromLast: function (count) {
                if (count <= 0 || count == null) return Enumerable.Empty();
                var source = this;

                return new Enumerable(function () {
                    var sourceEnumerator;
                    var enumerator;
                    var q = [];

                    return new IEnumerator(
                        function () { sourceEnumerator = source.GetEnumerator(); },
                        function () {
                            while (sourceEnumerator.MoveNext()) {
                                if (q.length == count) q.shift()
                                q.push(sourceEnumerator.Current());
                            }
                            if (enumerator == null) {
                                enumerator = Enumerable.From(q).GetEnumerator();
                            }
                            return (enumerator.MoveNext())
                                ? this.Yield(enumerator.Current())
                                : false;
                        },
                        function () { Utils.Dispose(enumerator); });
                });
            },

            IndexOf: function (item) {
                var found = null;
                this.ForEach(function (x, i) {
                    if (x === item) {
                        found = i;
                        return true;
                    }
                });

                return (found !== null) ? found : -1;
            },

            LastIndexOf: function (item) {
                var result = -1;
                this.ForEach(function (x, i) {
                    if (x === item) result = i;
                });

                return result;
            },

            /* Convert Methods */

            ToArray: function () {
                var array = [];
                this.ForEach(function (x) { array.push(x) });
                return array;
            },

            // Overload:function(keySelector)
            // Overload:function(keySelector, elementSelector)
            // Overload:function(keySelector, elementSelector, compareSelector)
            ToLookup: function (keySelector, elementSelector, compareSelector) {
                keySelector = Utils.CreateLambda(keySelector);
                elementSelector = Utils.CreateLambda(elementSelector);
                compareSelector = Utils.CreateLambda(compareSelector);

                var dict = new Dictionary(compareSelector);
                this.ForEach(function (x) {
                    var key = keySelector(x);
                    var element = elementSelector(x);

                    var array = dict.Get(key);
                    if (array !== undefined) array.push(element);
                    else dict.Add(key, [element]);
                });
                return new Lookup(dict);
            },

            ToObject: function (keySelector, elementSelector) {
                keySelector = Utils.CreateLambda(keySelector);
                elementSelector = Utils.CreateLambda(elementSelector);

                var obj = {};
                this.ForEach(function (x) {
                    obj[keySelector(x)] = elementSelector(x);
                });
                return obj;
            },

            // Overload:function(keySelector, elementSelector)
            // Overload:function(keySelector, elementSelector, compareSelector)
            ToDictionary: function (keySelector, elementSelector, compareSelector) {
                keySelector = Utils.CreateLambda(keySelector);
                elementSelector = Utils.CreateLambda(elementSelector);
                compareSelector = Utils.CreateLambda(compareSelector);

                var dict = new Dictionary(compareSelector);
                this.ForEach(function (x) {
                    dict.Add(keySelector(x), elementSelector(x));
                });
                return dict;
            },

            // Overload:function()
            // Overload:function(replacer)
            // Overload:function(replacer, space)
            ToJSON: function (replacer, space) {
                return JSON.stringify(this.ToArray(), replacer, space);
            },

            // Overload:function()
            // Overload:function(separator)
            // Overload:function(separator,selector)
            ToString: function (separator, selector) {
                if (separator == null) separator = "";
                if (selector == null) selector = Functions.Identity;

                return this.Select(selector).ToArray().join(separator);
            },


            /* Action Methods */

            // Overload:function(action<element>)
            // Overload:function(action<element,index>)
            Do: function (action) {
                var source = this;
                action = Utils.CreateLambda(action);

                return new Enumerable(function () {
                    var enumerator;
                    var index = 0;

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            if (enumerator.MoveNext()) {
                                action(enumerator.Current(), index++);
                                return this.Yield(enumerator.Current());
                            }
                            return false;
                        },
                        function () { Utils.Dispose(enumerator); });
                });
            },

            // Overload:function(action<element>)
            // Overload:function(action<element,index>)
            // Overload:function(func<element,bool>)
            // Overload:function(func<element,index,bool>)
            ForEach: function (action) {
                action = Utils.CreateLambda(action);

                var index = 0;
                var enumerator = this.GetEnumerator();
                try {
                    while (enumerator.MoveNext()) {
                        if (action(enumerator.Current(), index++) === false) break;
                    }
                }
                finally { Utils.Dispose(enumerator); }
            },

            // Overload:function()
            // Overload:function(separator)
            // Overload:function(separator,selector)
            Write: function (separator, selector) {
                if (separator == null) separator = "";
                selector = Utils.CreateLambda(selector);

                var isFirst = true;
                this.ForEach(function (item) {
                    if (isFirst) isFirst = false;
                    else document.write(separator);
                    document.write(selector(item));
                });
            },

            // Overload:function()
            // Overload:function(selector)
            WriteLine: function (selector) {
                selector = Utils.CreateLambda(selector);

                this.ForEach(function (item) {
                    document.write(selector(item));
                    document.write("<br />");
                });
            },

            Force: function () {
                var enumerator = this.GetEnumerator();

                try { while (enumerator.MoveNext()) { } }
                finally { Utils.Dispose(enumerator); }
            },

            /* Functional Methods */

            Let: function (func) {
                func = Utils.CreateLambda(func);
                var source = this;

                return new Enumerable(function () {
                    var enumerator;

                    return new IEnumerator(
                        function () {
                            enumerator = Enumerable.From(func(source)).GetEnumerator();
                        },
                        function () {
                            return (enumerator.MoveNext())
                                ? this.Yield(enumerator.Current())
                                : false;
                        },
                        function () { Utils.Dispose(enumerator); })
                });
            },

            Share: function () {
                var source = this;
                var sharedEnumerator;

                return new Enumerable(function () {
                    return new IEnumerator(
                        function () {
                            if (sharedEnumerator == null) {
                                sharedEnumerator = source.GetEnumerator();
                            }
                        },
                        function () {
                            return (sharedEnumerator.MoveNext())
                                ? this.Yield(sharedEnumerator.Current())
                                : false;
                        },
                        Functions.Blank
                    )
                });
            },

            MemoizeAll: function () {
                var source = this;
                var cache;
                var enumerator;

                return new Enumerable(function () {
                    var index = -1;

                    return new IEnumerator(
                        function () {
                            if (enumerator == null) {
                                enumerator = source.GetEnumerator();
                                cache = [];
                            }
                        },
                        function () {
                            index++;
                            if (cache.length <= index) {
                                return (enumerator.MoveNext())
                                    ? this.Yield(cache[index] = enumerator.Current())
                                    : false;
                            }

                            return this.Yield(cache[index]);
                        },
                        Functions.Blank
                    )
                });
            },

            /* Error Handling Methods */

            Catch: function (handler) {
                handler = Utils.CreateLambda(handler);
                var source = this;

                return new Enumerable(function () {
                    var enumerator;

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            try {
                                return (enumerator.MoveNext())
                                   ? this.Yield(enumerator.Current())
                                   : false;
                            }
                            catch (e) {
                                handler(e);
                                return false;
                            }
                        },
                        function () { Utils.Dispose(enumerator); });
                });
            },

            Finally: function (finallyAction) {
                finallyAction = Utils.CreateLambda(finallyAction);
                var source = this;

                return new Enumerable(function () {
                    var enumerator;

                    return new IEnumerator(
                        function () { enumerator = source.GetEnumerator(); },
                        function () {
                            return (enumerator.MoveNext())
                               ? this.Yield(enumerator.Current())
                               : false;
                        },
                        function () {
                            try { Utils.Dispose(enumerator); }
                            finally { finallyAction(); }
                        });
                });
            },

            /* For Debug Methods */

            // Overload:function()
            // Overload:function(message)
            // Overload:function(message,selector)
            Trace: function (message, selector) {
                if (message == null) message = "Trace";
                selector = Utils.CreateLambda(selector);

                return this.Do(function (item) {
                    console.log(message, ":", selector(item));
                });
            }
        }

        // private

        // static functions
        var Functions =
        {
            Identity: function (x) { return x; },
            True: function () { return true; },
            Blank: function () { }
        }

        // static const
        var Types =
        {
            Boolean: typeof true,
            Number: typeof 0,
            String: typeof "",
            Object: typeof {},
            Undefined: typeof undefined,
            Function: typeof function () { }
        }

        // static utility methods
        var Utils =
        {
            // Create anonymous function from lambda expression string
            CreateLambda: function (expression) {
                if (expression == null) return Functions.Identity;
                if (typeof expression == Types.String) {
                    if (expression == "") {
                        return Functions.Identity;
                    }
                    else if (expression.indexOf("=>") == -1) {
                        return new Function("$,$$,$$$,$$$$", "return " + expression);
                    }
                    else {
                        var expr = expression.match(/^[(\s]*([^()]*?)[)\s]*=>(.*)/);
                        return new Function(expr[1], "return " + expr[2]);
                    }
                }
                return expression;
            },

            IsIEnumerable: function (obj) {
                if (typeof Enumerator != Types.Undefined) {
                    try {
                        new Enumerator(obj);
                        return true;
                    }
                    catch (e) { }
                }
                return false;
            },

            Compare: function (a, b) {
                return (a === b) ? 0
                    : ((a > b) ? 1
                    : -1);
            },

            Dispose: function (obj) {
                if (obj != null) obj.Dispose();
            }
        }

        // IEnumerator State
        var State = { Before: 0, Running: 1, After: 2 }

        // name "Enumerator" is conflict JScript's "Enumerator"
        var IEnumerator = function (initialize, tryGetNext, dispose) {
            var yielder = new Yielder();
            var state = State.Before;

            this.Current = yielder.Current;
            this.MoveNext = function () {
                try {
                    switch (state) {
                        case State.Before:
                            state = State.Running;
                            initialize(); // fall through
                        case State.Running:
                            if (tryGetNext.apply(yielder)) {
                                return true;
                            }
                            else {
                                this.Dispose();
                                return false;
                            }
                        case State.After:
                            return false;
                    }
                }
                catch (e) {
                    this.Dispose();
                    throw e;
                }
            }
            this.Dispose = function () {
                if (state != State.Running) return;

                try { dispose(); }
                finally { state = State.After; }
            }
        }

        // for tryGetNext
        var Yielder = function () {
            var current = null;
            this.Current = function () { return current; }
            this.Yield = function (value) {
                current = value;
                return true;
            }
        }

        // for OrderBy/ThenBy

        var OrderedEnumerable = function (source, keySelector, descending, parent) {
            this.source = source;
            this.keySelector = Utils.CreateLambda(keySelector);
            this.descending = descending;
            this.parent = parent;
        }
        OrderedEnumerable.prototype = new Enumerable();

        OrderedEnumerable.prototype.CreateOrderedEnumerable = function (keySelector, descending) {
            return new OrderedEnumerable(this.source, keySelector, descending, this);
        }

        OrderedEnumerable.prototype.ThenBy = function (keySelector) {
            return this.CreateOrderedEnumerable(keySelector, false);
        }

        OrderedEnumerable.prototype.ThenByDescending = function (keySelector) {
            return this.CreateOrderedEnumerable(keySelector, true);
        }

        OrderedEnumerable.prototype.GetEnumerator = function () {
            var self = this;
            var buffer;
            var indexes;
            var index = 0;

            return new IEnumerator(
                function () {
                    buffer = [];
                    indexes = [];
                    self.source.ForEach(function (item, index) {
                        buffer.push(item);
                        indexes.push(index);
                    });
                    var sortContext = SortContext.Create(self, null);
                    sortContext.GenerateKeys(buffer);

                    indexes.sort(function (a, b) { return sortContext.Compare(a, b); });
                },
                function () {
                    return (index < indexes.length)
                        ? this.Yield(buffer[indexes[index++]])
                        : false;
                },
                Functions.Blank
            )
        }

        var SortContext = function (keySelector, descending, child) {
            this.keySelector = keySelector;
            this.descending = descending;
            this.child = child;
            this.keys = null;
        }

        SortContext.Create = function (orderedEnumerable, currentContext) {
            var context = new SortContext(orderedEnumerable.keySelector, orderedEnumerable.descending, currentContext);
            if (orderedEnumerable.parent != null) return SortContext.Create(orderedEnumerable.parent, context);
            return context;
        }

        SortContext.prototype.GenerateKeys = function (source) {
            var len = source.length;
            var keySelector = this.keySelector;
            var keys = new Array(len);
            for (var i = 0; i < len; i++) keys[i] = keySelector(source[i]);
            this.keys = keys;

            if (this.child != null) this.child.GenerateKeys(source);
        }

        SortContext.prototype.Compare = function (index1, index2) {
            var comparison = Utils.Compare(this.keys[index1], this.keys[index2]);

            if (comparison == 0) {
                if (this.child != null) return this.child.Compare(index1, index2)
                comparison = Utils.Compare(index1, index2);
            }

            return (this.descending) ? -comparison : comparison;
        }

        // optimize array or arraylike object

        var ArrayEnumerable = function (source) {
            this.source = source;
        }
        ArrayEnumerable.prototype = new Enumerable();

        ArrayEnumerable.prototype.Any = function (predicate) {
            return (predicate == null)
                ? (this.source.length > 0)
                : Enumerable.prototype.Any.apply(this, arguments);
        }

        ArrayEnumerable.prototype.Count = function (predicate) {
            return (predicate == null)
                ? this.source.length
                : Enumerable.prototype.Count.apply(this, arguments);
        }

        ArrayEnumerable.prototype.ElementAt = function (index) {
            return (0 <= index && index < this.source.length)
                ? this.source[index]
                : Enumerable.prototype.ElementAt.apply(this, arguments);
        }

        ArrayEnumerable.prototype.ElementAtOrDefault = function (index, defaultValue) {
            return (0 <= index && index < this.source.length)
                ? this.source[index]
                : defaultValue;
        }

        ArrayEnumerable.prototype.First = function (predicate) {
            return (predicate == null && this.source.length > 0)
                ? this.source[0]
                : Enumerable.prototype.First.apply(this, arguments);
        }

        ArrayEnumerable.prototype.FirstOrDefault = function (defaultValue, predicate) {
            if (predicate != null) {
                return Enumerable.prototype.FirstOrDefault.apply(this, arguments);
            }

            return this.source.length > 0 ? this.source[0] : defaultValue;
        }

        ArrayEnumerable.prototype.Last = function (predicate) {
            return (predicate == null && this.source.length > 0)
                ? this.source[this.source.length - 1]
                : Enumerable.prototype.Last.apply(this, arguments);
        }

        ArrayEnumerable.prototype.LastOrDefault = function (defaultValue, predicate) {
            if (predicate != null) {
                return Enumerable.prototype.LastOrDefault.apply(this, arguments);
            }

            return this.source.length > 0 ? this.source[this.source.length - 1] : defaultValue;
        }

        ArrayEnumerable.prototype.Skip = function (count) {
            var source = this.source;

            return new Enumerable(function () {
                var index;

                return new IEnumerator(
                    function () { index = (count < 0) ? 0 : count },
                    function () {
                        return (index < source.length)
                            ? this.Yield(source[index++])
                            : false;
                    },
                    Functions.Blank);
            });
        };

        ArrayEnumerable.prototype.TakeExceptLast = function (count) {
            if (count == null) count = 1;
            return this.Take(this.source.length - count);
        }

        ArrayEnumerable.prototype.TakeFromLast = function (count) {
            return this.Skip(this.source.length - count);
        }

        ArrayEnumerable.prototype.Reverse = function () {
            var source = this.source;

            return new Enumerable(function () {
                var index;

                return new IEnumerator(
                    function () {
                        index = source.length;
                    },
                    function () {
                        return (index > 0)
                            ? this.Yield(source[--index])
                            : false;
                    },
                    Functions.Blank)
            });
        }

        ArrayEnumerable.prototype.SequenceEqual = function (second, compareSelector) {
            if ((second instanceof ArrayEnumerable || second instanceof Array)
                && compareSelector == null
                && Enumerable.From(second).Count() != this.Count()) {
                return false;
            }

            return Enumerable.prototype.SequenceEqual.apply(this, arguments);
        }

        ArrayEnumerable.prototype.ToString = function (separator, selector) {
            if (selector != null || !(this.source instanceof Array)) {
                return Enumerable.prototype.ToString.apply(this, arguments);
            }

            if (separator == null) separator = "";
            return this.source.join(separator);
        }

        ArrayEnumerable.prototype.GetEnumerator = function () {
            var source = this.source;
            var index = 0;

            return new IEnumerator(
                Functions.Blank,
                function () {
                    return (index < source.length)
                        ? this.Yield(source[index++])
                        : false;
                },
                Functions.Blank);
        }

        // Collections

        var Dictionary = (function () {
            // static utility methods
            var HasOwnProperty = function (target, key) {
                return Object.prototype.hasOwnProperty.call(target, key);
            }

            var ComputeHashCode = function (obj) {
                if (obj === null) return "null";
                if (obj === undefined) return "undefined";

                return (typeof obj.toString === Types.Function)
                    ? obj.toString()
                    : Object.prototype.toString.call(obj);
            }

            // LinkedList for Dictionary
            var HashEntry = function (key, value) {
                this.Key = key;
                this.Value = value;
                this.Prev = null;
                this.Next = null;
            }

            var EntryList = function () {
                this.First = null;
                this.Last = null;
            }
            EntryList.prototype =
            {
                AddLast: function (entry) {
                    if (this.Last != null) {
                        this.Last.Next = entry;
                        entry.Prev = this.Last;
                        this.Last = entry;
                    }
                    else this.First = this.Last = entry;
                },

                Replace: function (entry, newEntry) {
                    if (entry.Prev != null) {
                        entry.Prev.Next = newEntry;
                        newEntry.Prev = entry.Prev;
                    }
                    else this.First = newEntry;

                    if (entry.Next != null) {
                        entry.Next.Prev = newEntry;
                        newEntry.Next = entry.Next;
                    }
                    else this.Last = newEntry;

                },

                Remove: function (entry) {
                    if (entry.Prev != null) entry.Prev.Next = entry.Next;
                    else this.First = entry.Next;

                    if (entry.Next != null) entry.Next.Prev = entry.Prev;
                    else this.Last = entry.Prev;
                }
            }

            // Overload:function()
            // Overload:function(compareSelector)
            var Dictionary = function (compareSelector) {
                this.count = 0;
                this.entryList = new EntryList();
                this.buckets = {}; // as Dictionary<string,List<object>>
                this.compareSelector = (compareSelector == null) ? Functions.Identity : compareSelector;
            }

            Dictionary.prototype =
            {
                Add: function (key, value) {
                    var compareKey = this.compareSelector(key);
                    var hash = ComputeHashCode(compareKey);
                    var entry = new HashEntry(key, value);
                    if (HasOwnProperty(this.buckets, hash)) {
                        var array = this.buckets[hash];
                        for (var i = 0; i < array.length; i++) {
                            if (this.compareSelector(array[i].Key) === compareKey) {
                                this.entryList.Replace(array[i], entry);
                                array[i] = entry;
                                return;
                            }
                        }
                        array.push(entry);
                    }
                    else {
                        this.buckets[hash] = [entry];
                    }
                    this.count++;
                    this.entryList.AddLast(entry);
                },

                Get: function (key) {
                    var compareKey = this.compareSelector(key);
                    var hash = ComputeHashCode(compareKey);
                    if (!HasOwnProperty(this.buckets, hash)) return undefined;

                    var array = this.buckets[hash];
                    for (var i = 0; i < array.length; i++) {
                        var entry = array[i];
                        if (this.compareSelector(entry.Key) === compareKey) return entry.Value;
                    }
                    return undefined;
                },

                Set: function (key, value) {
                    var compareKey = this.compareSelector(key);
                    var hash = ComputeHashCode(compareKey);
                    if (HasOwnProperty(this.buckets, hash)) {
                        var array = this.buckets[hash];
                        for (var i = 0; i < array.length; i++) {
                            if (this.compareSelector(array[i].Key) === compareKey) {
                                var newEntry = new HashEntry(key, value);
                                this.entryList.Replace(array[i], newEntry);
                                array[i] = newEntry;
                                return true;
                            }
                        }
                    }
                    return false;
                },

                Contains: function (key) {
                    var compareKey = this.compareSelector(key);
                    var hash = ComputeHashCode(compareKey);
                    if (!HasOwnProperty(this.buckets, hash)) return false;

                    var array = this.buckets[hash];
                    for (var i = 0; i < array.length; i++) {
                        if (this.compareSelector(array[i].Key) === compareKey) return true;
                    }
                    return false;
                },

                Clear: function () {
                    this.count = 0;
                    this.buckets = {};
                    this.entryList = new EntryList();
                },

                Remove: function (key) {
                    var compareKey = this.compareSelector(key);
                    var hash = ComputeHashCode(compareKey);
                    if (!HasOwnProperty(this.buckets, hash)) return;

                    var array = this.buckets[hash];
                    for (var i = 0; i < array.length; i++) {
                        if (this.compareSelector(array[i].Key) === compareKey) {
                            this.entryList.Remove(array[i]);
                            array.splice(i, 1);
                            if (array.length == 0) delete this.buckets[hash];
                            this.count--;
                            return;
                        }
                    }
                },

                Count: function () {
                    return this.count;
                },

                ToEnumerable: function () {
                    var self = this;
                    return new Enumerable(function () {
                        var currentEntry;

                        return new IEnumerator(
                            function () { currentEntry = self.entryList.First },
                            function () {
                                if (currentEntry != null) {
                                    var result = { Key: currentEntry.Key, Value: currentEntry.Value };
                                    currentEntry = currentEntry.Next;
                                    return this.Yield(result);
                                }
                                return false;
                            },
                            Functions.Blank);
                    });
                }
            }

            return Dictionary;
        })();

        // dictionary = Dictionary<TKey, TValue[]>
        var Lookup = function (dictionary) {
            this.Count = function () {
                return dictionary.Count();
            }

            this.Get = function (key) {
                return Enumerable.From(dictionary.Get(key));
            }

            this.Contains = function (key) {
                return dictionary.Contains(key);
            }

            this.ToEnumerable = function () {
                return dictionary.ToEnumerable().Select(function (kvp) {
                    return new Grouping(kvp.Key, kvp.Value);
                });
            }
        }

        var Grouping = function (key, elements) {
            this.Key = function () {
                return key;
            }

            ArrayEnumerable.call(this, elements);
        }
        Grouping.prototype = new ArrayEnumerable();

        // out to global
        return Enumerable;
    })();
    exports('linq', Enumerable);
});